package marketplace.jpa.dao;

import java.util.ArrayList;
import java.util.List;

import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import marketplace.jpa.datas.DataCategoria;
import marketplace.jpa.datas.DataContenidoDigital;
import marketplace.jpa.datas.DataSubcategoria;
import marketplace.jpa.datas.DataVersion;
import marketplace.jpa.entities.Administrador;
import marketplace.jpa.entities.Categoria;
import marketplace.jpa.entities.ContenidoDigital;
import marketplace.jpa.entities.Proveedor;
import marketplace.jpa.entities.RegistroAutorizacion;
import marketplace.jpa.entities.Subcategoria;
import marketplace.jpa.entities.Version;
import marketplace.jpa.interfaces.IContenidoDigitalDAO;

@Stateless
public class ContenidoDigitalDAO implements IContenidoDigitalDAO {

	@PersistenceContext(unitName="Marketplace")
	EntityManager em;
	
	
	
	//// VERSION /////////////////////////////////////////////////////////////////////
	
	@Override
	public boolean existeVersion(int id) throws Exception {
		boolean existe = false;
		try{
			Query q = em.createQuery("select c from Version c where c.idVersion = ?1");
			q.setParameter(1, id);
			if (!q.getSingleResult().equals(null)) existe = true;
		}
		catch(Exception e){
			System.out.println("Error DAO Version (Funcion existeVersion): " + e.getMessage());
		}
		return existe;
	}
	

	@Override
	public boolean existeVersionNumero(int idContenido, int numero) throws Exception {
		boolean existe = false;
		try{
			Query q = em.createQuery("select v from Version v where v.numero = ?1 and v.contDig.idContenido = ?2");
			q.setParameter(1, numero);
		    q.setParameter(2, idContenido);		
			if (!q.getSingleResult().equals(null)) existe = true;
		}
		catch(Exception e){
			System.out.println("Error DAO Version (Funcion existeVersion): " + e.getMessage());
		}
		return existe;
	}

	@Override
	public int guardarVersion(int numero, String nombre, Double precio, String estado, String archivo, Double tamanio, int idContenido) {
		int idver = -1;
		try{
			ContenidoDigital cd = em.find(ContenidoDigital.class, idContenido);			
			Version Ver = new Version(numero, nombre, precio, estado, archivo, tamanio, cd);
			em.persist(Ver);
			em.flush();
			idver = Ver.getIdVersion();
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion guardarVersion (parametros)): " + e.getMessage());
		}
		return idver;
	}

	@SuppressWarnings({ "unchecked" })
	@Override
	public List<DataVersion> getVersiones(int idContenido) throws Exception {
		ArrayList<DataVersion> lstdVer = new ArrayList<DataVersion>();
		try{
			//ContenidoDigital c = em.find(ContenidoDigital.class, idContenido);
			Query q = em.createQuery("select v from Version v where v.contDig = ?1)");
			q.setParameter(1, idContenido);			
			List<Version> lstVer = (List<Version>) q.getResultList();
			for (Version Ver : lstVer) {
				DataVersion dVer = new DataVersion(Ver);
				lstdVer.add(dVer);
			}
		}catch(Exception e){
			System.out.println("Error DAO Version (Funcion existVersionVer): " + e.getMessage());
		}				
		return lstdVer;
	}	
	
	@Override
	public void modificarVersion(DataVersion Ver) throws Exception {
		try{
			Version v = em.find(Version.class, Ver.getIdVersion());
			v.dataToContenido(Ver);
			em.persist(v);
			em.flush();
		}catch(Exception e){
			System.out.println("ERROR DAOVersion (Funcion modificarVersion): " + e.getMessage());
		}
	}

	@Override
	public void eliminarVersion(int id) throws Exception {
		try{				
			 Version Ver = em.find(Version.class, id);
			 em.remove(Ver);
			 em.flush();
		} catch(Exception e){
			System.out.println("ERROR DAOVersion (Funcion eliminarVersion): " + e.getMessage());
		}	
	}

	@Override
	public List<DataVersion> getVersiones() throws Exception {
		ArrayList<DataVersion> lstdVer = new ArrayList<DataVersion>();
		try{			
			Query q = em.createQuery("select c from Version c)");
			@SuppressWarnings("unchecked")
			List<Version> lstVer = (List<Version>) q.getResultList();
			for (Version Ver : lstVer) {
				DataVersion dVer = new DataVersion(Ver);
				lstdVer.add(dVer);
			}
		}catch(Exception e){
			System.out.println("Error DAO Version (Funcion existVersionVer): " + e.getMessage());
		}				
		return lstdVer;
	}

	@Override
	public DataVersion obtenerVersion(int id) throws Exception {
		DataVersion dVer = new DataVersion();
		try{			
			Version c = em.find(Version.class, id);
			dVer = new DataVersion(c);
		}catch(Exception e){
			System.out.println("Error DAO Version (Funcion obtenerVersion(id)): " + e.getMessage());
		}
		return dVer;
	}
	
	@Override
	public List<DataContenidoDigital> getContenidosConVersionesAprobadas() throws Exception {
		ArrayList<DataContenidoDigital> lstdVer = new ArrayList<DataContenidoDigital>();
		try{			
			Query q = em.createQuery("select v from Version v where v.estadoAprobacion = ?1");
			q.setParameter(1, "APROBADA");
		    
			@SuppressWarnings("unchecked")
			List<Version> lstVer = (List<Version>) q.getResultList();
			for (Version Ver : lstVer) {
				DataVersion dVer = new DataVersion(Ver);
				lstdVer.add(dVer.getContDig());
			}
		}catch(Exception e){
			System.out.println("Error DAO Version (Funcion existVersionVer): " + e.getMessage());
		}				
		return lstdVer;
	}
	

	@Override
	public int getUltimaVersionAutorizada(int idContenido) throws Exception {
		int devolver = -1;
		try{			
			Query q = em.createQuery("select v from Version v where v.estadoAprobacion = ?1 and v.contDig.idContenido = ?2 order by v.fechaCreacion desc");
			q.setParameter(1, "APROBADA");
			q.setParameter(2, idContenido);			
			@SuppressWarnings("unchecked")
			List<Version> vs = (List<Version>) q.getResultList();
			if (!vs.equals(null)){
				devolver = vs.get(0).getIdVersion(); 
			}
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion getUltimaVersionAutorizada): " + e.getMessage());
		}				
		return devolver;
	}

	@Override
	public DataVersion obtenerDataUltimaVersionAutorizada(int idContenido) throws Exception {
		DataVersion devolver = new DataVersion();
		try{			
			Query q = em.createQuery("select v from Version v where v.estadoAprobacion = ?1 and v.contDig.idContenido = ?2 order by v.fechaCreacion desc");
			q.setParameter(1, "APROBADA");
			q.setParameter(2, idContenido);			
			@SuppressWarnings("unchecked")
			List<Version> vs = (List<Version>) q.getResultList();
			if (!vs.equals(null)){
				devolver = new DataVersion(vs.get(0)); 
			}
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion getUltimaVersionAutorizada): " + e.getMessage());
		}				
		return devolver;
	}
	
	@Override
	public void eliminarVersionesContenidoDigital(int idContenido){
		try{
			Query q = em.createQuery("select v from Version v where v.contDig.idContenido = ?1");
			q.setParameter(1, idContenido);
			@SuppressWarnings("unchecked")
			List<Version> vs = (List<Version>) q.getResultList();
			for (Version Ver : vs) {
				em.remove(Ver);
			}
			em.flush();			
		} catch(Exception e){
			System.out.println("ERROR DAOVersion (Funcion eliminarVersionesContenidoDigital): " + e.getMessage());
		}	
		
	}

	
	//// CONTENIDO DIGITAL /////////////////////////////////////////////////////////////////
		

	public boolean existVersionCD(int idVer, int idCD){
		boolean existe = false;
		try{			
			Query q = em.createQuery("select u from Version u where u.idVersion = ?1 and u.idContenido = ?2");
			q.setParameter(1, idVer);
		    q.setParameter(2, idCD);
		    
		    int cant = q.getMaxResults();
		    if( cant > 0) existe = true;
		} 
		catch(Exception e){
			System.out.println("Error DAO ContenidoDigital (Funcion existVersionCD): " + e.getMessage());
		}				
		return existe;
	}

	@Override
	public boolean existeContenidoDigital(int id) throws Exception {
		boolean existe = false;
		try{
			Query q = em.createQuery("select c from ContenidoDigital c where c.idContenido = ?1");
			q.setParameter(1, id);
			if (!q.getSingleResult().equals(null)) existe = true;
		}
		catch(Exception e){
			System.out.println("Error DAO ContenidoDigital (Funcion existeContenidoDigital): " + e.getMessage());
		}
		return existe;
	}
	

	@Override
	public boolean existeContenidoDigital(String nombre) throws Exception {
		boolean existe = false;
		try{
			Query q = em.createQuery("select c from ContenidoDigital c where c.nombre = ?1");
			q.setParameter(1, nombre);
			if (!q.getSingleResult().equals(null)) existe = true;
		}
		catch(Exception e){
			System.out.println("Error DAO ContenidoDigital (Funcion existeContenidoDigital): " + e.getMessage());
		}
		return existe;
	}
			

	@Override
	public boolean guardarContenidoDigital(DataContenidoDigital dcd) throws Exception {
		boolean resultado = false;
		ContenidoDigital cd = new ContenidoDigital(dcd);
		try{			
			em.persist(cd);
			System.out.println("DAOContenidoDigital (Funcion guardarContenidoDigital): " + cd.getNombre());
			em.flush();
			resultado = true;
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion guardarContenidoDigital): " + e.getMessage());
		}
		return resultado;
	}

	@Override
	public int guardarContenidoDigital(String nombre, String descripcion, String videos, String subcategoria, String propietario) {
		int idcontenido = -1;
		try{
			Subcategoria scat = em.find(Subcategoria.class, subcategoria);
			Proveedor prov = em.find(Proveedor.class, propietario);			
			ContenidoDigital cd = new ContenidoDigital(nombre, descripcion, videos, scat, prov);
			em.persist(cd);
			em.flush();
			idcontenido = cd.getIdContenido();
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion guardarContenidoDigital (parametros)): " + e.getMessage());
		}
		return idcontenido;
	}

	@SuppressWarnings({ "unchecked" })
	@Override
	public List<DataContenidoDigital> getContenidoDigitalesProveedor(String mail) throws Exception {
		ArrayList<DataContenidoDigital> lstdCd = new ArrayList<DataContenidoDigital>();
		try{			
			Query q = em.createQuery("select c from ContenidoDigital c where c.propietario.mail = ?1)");
			q.setParameter(1, mail);
			List<ContenidoDigital> lstCd = (List<ContenidoDigital>) q.getResultList();
			for (ContenidoDigital cd : lstCd) {
				DataContenidoDigital dcd = new DataContenidoDigital(cd);
				lstdCd.add(dcd);
			}
		}catch(Exception e){
			System.out.println("Error DAO ContenidoDigital (Funcion getContenidosDigitalesProveedor): " + e.getMessage());
		}				
		return lstdCd;
	}	
	
	@Override
	public void modificarContenidoDigital(DataContenidoDigital cd) throws Exception {
		try{
			
			ContenidoDigital c = em.find(ContenidoDigital.class, cd.getIdContenido());
			Subcategoria sc = em.find(Subcategoria.class, cd.getSubcategoria());
			c.setNombre(cd.getNombre());
			c.setDescripcion(cd.getDescripcion());
			c.setVideo(cd.getVideo());
			c.setSubcategoria(sc);
			
			em.persist(c);
			em.flush();
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion modificarContenidoDigital): " + e.getMessage());
		}		
	}

	@Override
	public void eliminarContenidoDigital(int id) throws Exception {
		try{				
			 ContenidoDigital cd = em.find(ContenidoDigital.class, id);			 
			 em.remove(cd);
			 em.flush();
		} catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion eliminarContenidoDigital): " + e.getMessage());
		}	
	}

	@Override
	public List<DataContenidoDigital> getContenidoDigitales() throws Exception {
		ArrayList<DataContenidoDigital> lstdCd = new ArrayList<DataContenidoDigital>();
		try{			
			Query q = em.createQuery("select c from ContenidoDigital c order by c.nombre");
			@SuppressWarnings("unchecked")
			List<ContenidoDigital> lstCd = (List<ContenidoDigital>) q.getResultList();
			for (ContenidoDigital cd : lstCd) {
				DataContenidoDigital dcd = new DataContenidoDigital(cd);
				lstdCd.add(dcd);
			}
			em.flush();			
		}catch(Exception e){
			//System.out.println("Error DAO ContenidoDigital (Funcion getContenidosDigitales): " + e.getMessage());
			e.printStackTrace();
		}				
		return lstdCd;	
	}

	@Override
	public DataContenidoDigital obtenerContenidoDigital(int id) throws Exception {
		DataContenidoDigital dcd = new DataContenidoDigital();
		try{			
			ContenidoDigital c = em.find(ContenidoDigital.class, id);
			dcd = new DataContenidoDigital(c);
		}catch(Exception e){
			System.out.println("Error DAO ContenidoDigital (Funcion obtenerContenidoDigital(id)): " + e.getMessage());
		}
		return dcd;
	}
	
	@Override
	public int getCantidadDescargasContenidoDigital(int idContenido) throws Exception {
		int total = 0;
		try{			
			Query q = em.createQuery("select v from Version v where v.estadoAprobacion = ?1 and v.contDig.idContenido = ?2");
			q.setParameter(1, "APROBADA");
			q.setParameter(2, idContenido);
			@SuppressWarnings("unchecked")
			List<Version> vs = (List<Version>) q.getResultList();
			if (!vs.equals(null)){
				for (Version version : vs) {
					total += version.getCantDescragas();
				}
			}
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion getCantidadDescargasContenidoDIgital): " + e.getMessage());
		}				
		return total;
	}	

	
	//// CATEGORIA /////////////////////////////////////////////////////////////////	
	
	@Override
	public boolean existeCategoria(String nombre) throws Exception {
		boolean existe = false;
		try{			
			Query q = em.createQuery("select u from Categoria u where u.nombreCategoria = ?1");
			q.setParameter(1, nombre);
			if (!q.getSingleResult().equals(null)) existe = true;
			em.flush();
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion existeCategoria): " + e.getMessage());
		}				
		return existe;
	}

	@Override
	public boolean guardarCategoria(DataCategoria da) throws Exception {
		boolean resultado = false;
		Categoria c = new Categoria(da);
		try{			
			em.persist(c);			
			em.flush();
			resultado = true;
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion guardarCategoria): " + e.getMessage());
		}
		return resultado;
	}

	@Override
	public void modificarCategoria(DataCategoria da) throws Exception {
		try{
			Categoria cat = em.find(Categoria.class, da.getNombre());
			cat.setFromData(da);
			em.persist(cat);
			System.out.println("DAOContenidoDigtal - modificarCategoria: " + da.getNombre() + " / " + da.getDescripcion());			 
			em.flush();
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion modificarCategoria): " + e.getMessage());
		}
	}

	@Override
	public void eliminarCategoria(String nombre) throws Exception {
		try{				
			 Categoria c = em.find(Categoria.class, nombre);
			 System.out.println("DAOContenidoDigtal - eliminarCategoria: " + nombre);
			 em.remove(c);
			 em.flush();
		} catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion eliminarCategoria): " + e.getMessage());
		}		
	}

	@Override
	public List<DataCategoria> getCategorias() throws Exception {
		List<DataCategoria> lstCat= new ArrayList<DataCategoria>();
		try{
			Query q = em.createQuery("select c from Categoria c order by c.nombreCategoria");
			@SuppressWarnings("unchecked")
			List<Categoria> lstCatDB = (List<Categoria>) q.getResultList();
			for (Categoria cb : lstCatDB) {
				DataCategoria dub = new DataCategoria(cb);
				lstCat.add(dub);
			}
			em.flush();
		}
		catch(Exception e){ System.out.println("ERROR DAOContenidoDigital (Funcion getCategorias): " + e.getMessage()); }				
		return lstCat;
	}

	@Override
	public DataCategoria obtenerCategoria(String nombreCategoria) throws Exception {
		DataCategoria dc = new DataCategoria();
		try {
			//System.out.println("DAO ContenidoDigital (obtenerCategoria): nombre " + nombreCategoria + "//");
			Categoria cat = em.find(Categoria.class, nombreCategoria);
			dc = new DataCategoria(cat);
			em.flush();
		} catch (Exception e) {
			System.out.println("ERROR DAOContenidoDigital (Funcion obtenerCategoria): " + e.getMessage());		
		}
		return dc;
	}

	
	//// SUBCATEGORIA /////////////////////////////////////////////////////////////////	
	
	@Override
	public boolean existeSubCategoria(String scnombre, String categoria) throws Exception {
		boolean existe = false;
		try{			
			Query q = em.createQuery("select sc from Subcategoria sc where sc.nombreSubcategoria = ?1 and sc.categoria.nombreCategoria = ?2");
			q.setParameter(1, scnombre);
			q.setParameter(2, categoria);
			if (!q.getSingleResult().equals(null)) existe = true;		
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion existeSubcategoria): " + e.getMessage());
		}
		return existe;
	}

	@Override
	public boolean guardarSubCategoria(DataSubcategoria dsc) throws Exception {
		boolean resultado = false;
		Subcategoria sc = new Subcategoria(dsc);
		try{			
			em.persist(sc);
			em.flush();
			resultado = true;
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion guardarSubcategoria): " + e.getMessage());
		}
		return resultado;
	}

	@Override
	public void modificarSubCategoria(DataSubcategoria dsc) throws Exception {
		try{
			Subcategoria sc = em.find(Subcategoria.class, dsc.getNombre());
			sc.setFromData(dsc);
			em.persist(sc);
			System.out.println("DAOContenidoDigtal - modificarSubcategoria: " + dsc.getNombre() + " / " + dsc.getDescripcion() + " / " + dsc.getCategoria().getNombre());			 
			em.flush();
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion modificarSubcategoria): " + e.getMessage());
		}
		
	}

	@Override
	public void eliminarSubCategoria(String sc) throws Exception {
		try{				
			 Subcategoria scat = em.find(Subcategoria.class, sc);
			 System.out.println("DAOContenidoDigtal - eliminarSubcategoria: " + sc);
			 em.remove(scat);
			 em.flush();
		} catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion eliminarSubcategoria): " + e.getMessage());
		}		
	}

	@Override
	public List<DataSubcategoria> getSubCategorias() throws Exception {
		List<DataSubcategoria> lstSubcat= new ArrayList<DataSubcategoria>();
		try{
			Query q = em.createQuery("select sc from Subcategoria sc order by sc.nombreSubcategoria");
			@SuppressWarnings("unchecked")
			List<Subcategoria> lstSCatDB = (List<Subcategoria>) q.getResultList();
			for (Subcategoria scb : lstSCatDB) {
				DataSubcategoria dub = new DataSubcategoria(scb);
				lstSubcat.add(dub);
			}
		}
		catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion getSubcategorias): " + e.getMessage());
		}				
		return lstSubcat;
	}	
	
	@Override
	public List<DataSubcategoria> getSubCategoriasPorCategoria(String categoria) throws Exception {
		List<DataSubcategoria> lstSubcat= new ArrayList<DataSubcategoria>();
		try{
			Query q = em.createQuery("select sc from Subcategoria sc where sc.categoria.nombreCategoria = ?1 order by sc.nombreSubcategoria");
			q.setParameter(1, categoria);
			@SuppressWarnings("unchecked")
			List<Subcategoria> lstSCatDB = (List<Subcategoria>) q.getResultList();
			for (Subcategoria scb : lstSCatDB) {
				DataSubcategoria dub = new DataSubcategoria(scb);
				lstSubcat.add(dub);
			}
		} 
		catch(Exception e){ System.out.println("ERROR DAOContenidoDigital (Funcion getSubcategoriasPorCategoria): " + e.getMessage()); }				
		return lstSubcat;
	}

	@Override
	public DataSubcategoria obtenerSubCategoria(String scnombre) {
		DataSubcategoria dsc = new DataSubcategoria();
		try{			
			Query q = em.createQuery("select sc from Subcategoria sc where sc.nombreSubcategoria = ?1");
			q.setParameter(1, scnombre);
			Subcategoria sc = (Subcategoria) q.getSingleResult();
			if (!sc.equals(null)){
				dsc = new DataSubcategoria(sc.getNombreSubcategoria(), sc.getDescripcion(), new DataCategoria(sc.getCategoria()));
			}
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion obtenerSubcategoria): " + e.getMessage());
		}				
		return dsc;
	}


	@Override
	public void eliminarSubcategoriasCategoria(String categoria){
		try{
			Query q = em.createQuery("select sc from Subcategoria sc where sc.categoria.nombreCategoria = ?1");
			q.setParameter(1, categoria);
			@SuppressWarnings("unchecked")
			List<Subcategoria> sc = (List<Subcategoria>) q.getResultList();
			for (Subcategoria Sub : sc) {
				em.remove(Sub);
			}
			em.flush();			
		} catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion eliminarSubcategoriasCategoria): " + e.getMessage());
		}		
	}


	//// REGISTRO DE AUTORIZACION /////////////////////////////////////////////////////////////////	
	
	@Override
	public void guardarRegistroDeAutorizacion(String administrador, int idVersion, String observacion) throws Exception {		
		try{
			Version ver = em.find(Version.class, idVersion);
			Administrador admin = em.find(Administrador.class, administrador);
			RegistroAutorizacion ra = new RegistroAutorizacion(ver.getEstadoAprobacion(), observacion, admin, ver);
			em.persist(ra);
			em.flush();
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion guardarRegistroDeAutorizacion (parametros)): " + e.getMessage());
		}
				
	}	
	
	@Override
	@TransactionAttribute(TransactionAttributeType.REQUIRED)
	public List<DataContenidoDigital> obtenerBusqueda(String valor) {
		List<DataContenidoDigital> lst = new ArrayList<DataContenidoDigital>();
		try {
			/*Query q = em.createQuery("select * from contenidodigital c where c.idcontenido in (select v.contdig_idcontenido from version v where  c.idcontenido = v.contdig_idcontenido  and v.contdig_idcontenido = c.idcontenido and (v.estadoAprobacion = 'APROBADA'  and (upper(c.nombre) like '%"+ valor.toUpperCase() +"%' or upper(c.descripcion) like '%" + valor.toUpperCase() + "%' )) order by v.fechacreacion desc limit 1)");*/
			
			/*Me tira error: en el *, el limmit 1, y que no esta mapeado conteidodigital*/
			Query q = em.createQuery("select c from ContenidoDigital c where c.idContenido in (select v.contDig.idContenido from Version v where  c.idContenido = v.contDig.idContenido and v.contDig.idContenido = c.idContenido and (v.estadoAprobacion = 'APROBADA'  and (upper(c.nombre) like '%"+ valor.toUpperCase() +"%' or upper(c.descripcion) like '%" + valor.toUpperCase() + "%' )) order by v.fechaCreacion desc)");
			
			@SuppressWarnings("unchecked")
			List<ContenidoDigital> cds = q.getResultList();
			for (ContenidoDigital contenidoDigital : cds) {
				lst.add(new DataContenidoDigital(contenidoDigital));
			}
		} catch (Exception e) {
			System.out.println("Error DAO Usuario Funcion obtenerBusqueda: " + e.getMessage());
		}	
		return lst;
	}


	@Override
	public boolean existeSubCategoriaNombre(String nombre) {
		boolean existe = false;
		try{			
			Query q = em.createQuery("select sc from Subcategoria sc where sc.nombreSubcategoria = ?1");
			q.setParameter(1, nombre);
			if (!q.getSingleResult().equals(null)) existe = true;		
		}catch(Exception e){
			System.out.println("ERROR DAOContenidoDigital (Funcion existeSubcategoriaNombre): " + e.getMessage());
		}
		return existe;
	}	
	

	       
	       
	
	
}
